home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / gui / precog2_1.lha / Precognition2_1 / src / src.lha / Precognition / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-09  |  14.7 KB  |  565 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <exec/types.h>
  4. #include <exec/nodes.h>
  5. #include <exec/lists.h>
  6. #include <exec/ports.h>
  7. #include <graphics/layers.h>
  8. #include <graphics/gfxbase.h>
  9. #include <intuition/intuition.h>
  10. #include "amigamem.h"
  11. #include "intuition_utils.h"
  12. #ifndef __GNUC__
  13. #include <clib/exec_protos.h>
  14. #include <clib/alib_protos.h>
  15. #include <clib/intuition_protos.h>
  16. #include <clib/graphics_protos.h>
  17. #endif
  18. #ifdef __GNUC__
  19. #include <proto/exec.h>
  20. #include <proto/alib.h>
  21. #include <proto/intuition.h>
  22. #include <proto/graphics.h>
  23. #endif
  24. #ifdef __SASC
  25. #include <proto/exec.h>
  26.  /* no <proto/alib.h> file with SAS/C */
  27. #include <proto/intuition.h>
  28. #include <proto/graphics.h>
  29. #endif
  30.  
  31. #include "precognition.h"
  32. #include "BuilderWindow.h"
  33. #include "BuilderMethods/BuilderMethods.h"
  34. #include "GridSnapWindow.h"
  35. #include "Menus/pcg_Menus.h"
  36. #include "Menus/Menustuff.h"
  37. #include "ToolWindow.h"
  38. #include "ChainedWindows.h"
  39. #include "Prefs/pcgPrefs.h"
  40. #include "AutoCleanUp.h"
  41. #include "FileRequester/pcg_FileReq.h"
  42. #include "project.h"
  43. #include "funclists.h"
  44. #include "BuilderMethods/patchClasses.h"
  45.  
  46. /* Missing prototype -- EDB */
  47. void Builder_EventLoop(void);
  48. void GracefulExit( short ExitStatus );
  49. void EditEnvironment( struct MsgPort *shared_port );
  50.  
  51.  
  52.  
  53. /* declare lib structures */
  54. struct IntuitionBase *IntuitionBase = NULL;
  55. struct GfxBase       *GfxBase       = NULL;
  56. struct LayersBase    *LayersBase    = NULL;
  57. struct Library       *IconBase      = NULL;
  58.  
  59. char silly;
  60. #define WAITCHAR scanf( "%c\n", &silly )
  61. #define DUMPWAIT(s) printf( s ); WAITCHAR
  62.  
  63. struct FileReqInfo filereq_info;
  64.  
  65. #ifdef __SASC
  66. int __stack = 10000; /* min stacksize */
  67. #endif
  68.  
  69.                       /* Upped Version & Revision -- EDB */
  70. char *Precognition_version = "$VER: Precognition 2.1 (9.1.95)";
  71.    /*
  72.    ** This string needs to be in there somewhere for the
  73.    ** AmigaDOS VERSION command to find it.
  74.    */
  75.  
  76. struct pcgPreferences pcg_prefs =
  77. {
  78.    DONT_KNOW      /* Interlace */
  79. };
  80.  
  81. void RestorePrevDir( void );
  82.  
  83. struct Screen        *screen        = NULL;
  84.  
  85. struct NewScreen screen_request =
  86. {
  87.    0,0,              /* Left edge, Top edge     */
  88.    640, 400,         /* Width, Height           */
  89.    2,                /* Depth                   */
  90.    0, 1,             /* Detail Pen, Block Pen   */
  91.    HIRES,            /* View Modes              */
  92.    CUSTOMSCREEN,     /* Type of screen          */
  93.    &pcg_Topaz80,     /* Screen Font.            */
  94.    "Precognition",   /* Title                   */
  95.    NULL,             /* Screen Gadgets          */
  96.    NULL              /* Custom Bitmap           */
  97. };
  98.  
  99.  
  100. struct MsgPort *shared_port = NULL; /* initialized to NULL -- EDB */
  101.  
  102. int main( int argc, char **argv  )
  103. {
  104.  
  105.    /* open intuition library */
  106.    IntuitionBase = (struct IntuitionBase *)
  107.       OpenLibrary( "intuition.library", 0 );
  108.    if( IntuitionBase == NULL )
  109.    {
  110.       printf( "couldn't open intuition.library\n" );
  111.       GracefulExit( FALSE );
  112.    }
  113.  
  114.    GfxBase = (struct GfxBase *)
  115.       OpenLibrary( "graphics.library", 0 );
  116.    if( GfxBase == NULL )
  117.    {
  118.       printf( "couldn't open graphics.library\n");
  119.       GracefulExit( FALSE );
  120.    }
  121.  
  122.    LayersBase = (struct LayersBase *)
  123.       OpenLibrary( "layers.library", 0 );
  124.    if( LayersBase == NULL )
  125.    {
  126.       printf( "couldn't open layers.library\n");
  127.       GracefulExit( FALSE );
  128.    }
  129.  
  130.    IconBase = OpenLibrary( "icon.library", 0 );
  131.    if( IconBase == NULL )
  132.    {
  133.       printf( "couldn't open icon.library\n" );
  134.       GracefulExit( FALSE );
  135.    }
  136.  
  137.    /*
  138.    // Install Builder methods into the Precognition classes
  139.    */
  140.    patchClasses();
  141.  
  142.    Project_Init();
  143.  
  144.    /* DUMPWAIT("getting prefs\n"); */
  145.    pcgGetPrefs( argc, argv, &pcg_prefs );
  146.  
  147.    screen_request.Width  = GfxBase->NormalDisplayColumns;
  148.    screen_request.Height = GfxBase->NormalDisplayRows;
  149.    if( pcg_prefs.Interlace )
  150.    {
  151.       screen_request.ViewModes |= LACE;
  152.       screen_request.Height *= 2;
  153.    }
  154.  
  155.    /* DUMPWAIT("opening screen\n"); */
  156.    screen = SmartOpenScreen( &screen_request );
  157.    if( screen == NULL )
  158.    {
  159.       printf("Couldn't open a screen.\n");
  160.       GracefulExit( FALSE );
  161.    }
  162.  
  163.    if( ( shared_port = (struct MsgPort *)CreatePort( NULL, 0 ) ) == NULL )
  164.    {
  165.       printf("couldn't create a Message port.\n");
  166.       GracefulExit( FALSE );
  167.    }
  168.  
  169.  
  170.    filereq_info.screen         = screen;
  171.    filereq_info.SharedUserPort = shared_port;
  172.    filereq_info.filter         = NULL;
  173.  
  174.    /* printf("calling EditEnvironment\n"); */
  175.    EditEnvironment( shared_port );
  176.  
  177.    GracefulExit( TRUE );
  178.  
  179.    return 0;
  180. }
  181.  
  182. /* Via some linker-magic, this function is automatically called at
  183.    exit.  This allows graceful cleanup after stack-overflows.
  184.    (Except that it doesn't work.)
  185.  
  186.    It is also explicitly called by GracefulExit.
  187. */
  188.  
  189. void __STDCleanUp( void )
  190. {
  191.    AutoCleanUp();
  192.  
  193.    RestorePrevDir();
  194.  
  195.    if( shared_port )
  196.    {
  197.       DeletePort( shared_port );
  198.       shared_port = NULL;
  199.    }
  200.  
  201.    /* Close all windows, screens, libraries. */
  202.  
  203.    if( screen )
  204.    {
  205.       CloseScreen( screen );
  206.       screen = NULL;
  207.    }
  208.  
  209.    if( IconBase )
  210.    {
  211.       CloseLibrary( (struct Library *)IconBase );
  212.       IconBase = NULL;
  213.    }
  214.  
  215.    if( LayersBase )
  216.    {
  217.       CloseLibrary( (struct Library *)LayersBase );
  218.       LayersBase = NULL;
  219.    }
  220.  
  221.    if( GfxBase )
  222.    {
  223.       CloseLibrary( (struct Library *)GfxBase );
  224.       GfxBase = NULL;
  225.    }
  226.  
  227.    if( IntuitionBase )
  228.    {
  229.       CloseLibrary( (struct Library *)IntuitionBase );
  230.       IntuitionBase = NULL;
  231.    }
  232. }
  233.  
  234.  
  235. void GracefulExit( short ExitStatus )
  236. {
  237.    __STDCleanUp();
  238.    exit( ExitStatus );
  239. }
  240.  
  241.  
  242. void main_ParseMenuEvent( BuilderWindow *bw,
  243.                           USHORT   MenuNumber,
  244.                           Window  *window );
  245.  
  246. void main_PositionTools( Screen     *screen,
  247.                          ToolWindow *tw1,
  248.                          ToolWindow *tw2 );
  249.  
  250.  
  251. char *cyclegadget_choices[] =
  252.    {
  253.       "this",
  254.       "that",
  255.       "the other",
  256.       NULL        /* _must_ be terminated by a NULL */
  257.    };
  258.  
  259.  
  260. Menu             *menustrip = NULL;
  261. GridSnapWindow    gridsnapwindow;
  262. ToolWindow        GraphicTool, IactorTool;
  263. BuilderWindow     builderwindow;
  264.  
  265. /* pcg_3DPens StandardPens( void ); */
  266.  
  267. struct MinList    DeferredResponses;
  268.  
  269. void Builder_Init( void )
  270. {
  271.    pcg_3DPens        pens;
  272.  
  273. /*   pens = StandardPens(); */
  274.    pens = StandardScreenPens( NULL );
  275.  
  276.    /* set up window to share its UserPort with other window. */
  277.    /* DUMPWAIT("builderinit\n");  */
  278.    BuilderWindow_Init( &builderwindow, 0,12, 640, 200, pens,
  279.                         "application", screen, &gridsnapwindow.gridinfo );
  280.  
  281.    builderwindow.pw.SharedUserPort = shared_port;
  282.    AddMenuStrip( &builderwindow.pw, menustrip );
  283.    AddWindowToChain( &builderwindow.pw );
  284.  
  285. }
  286.  
  287.  
  288. void Builder_CleanUp( void )
  289. {
  290.    pcgCloseWindow( &builderwindow.pw );
  291.    RemoveWindowFromChain( &builderwindow.pw );
  292.    CleanUp( (struct PObject *)&builderwindow.pw );
  293. }
  294.  
  295. void Builder_Reset( BOOL reopen )
  296. {
  297.    Builder_CleanUp();
  298.    Builder_Init();
  299.  
  300.    if( reopen )
  301.    {
  302.       if( ! pcgOpenWindow( &builderwindow.pw ) )
  303.       {
  304.          printf( "couldn't open window\n" );
  305.          GracefulExit( FALSE );
  306.       }
  307.    }
  308.  
  309. }
  310.  
  311. extern char* proj_filename;
  312.  
  313. BOOL Builder_ParseArgs( void )
  314. {
  315.    if( proj_filename )
  316.    {
  317.       Project_ReadIFF();
  318.    }
  319.    return TRUE;
  320. }
  321.  
  322. void Builder_EventLoop()
  323. {
  324.    IntuiMessage     *message, local_msg;
  325.    struct FuncNode  *node;
  326.  
  327.    NewList( (struct List*) &DeferredResponses );
  328.    Builder_Init();
  329.  
  330.    if( Builder_ParseArgs() )
  331.    {
  332.       if( ! pcgOpenWindow( &builderwindow.pw ) )
  333.       {
  334.          printf( "couldn't open window\n" );
  335.          GracefulExit( FALSE );
  336.       }
  337.  
  338.       while( ! Project_Done() )
  339.       {
  340.          message   = WaitForMessage( shared_port );
  341.          local_msg = *message;
  342.  
  343.          if( local_msg.Class == MENUVERIFY )
  344.          {
  345.             Respond( (struct Interactor *)&builderwindow.pw, message );
  346.             Respond( (struct Interactor *)&gridsnapwindow.pw, message );
  347.          }
  348.          ReplyMsg( (struct Message *)message );
  349.  
  350.  
  351.          switch( local_msg.Class )
  352.          {
  353.             case MENUPICK:
  354.                main_ParseMenuEvent( &builderwindow, local_msg.Code,
  355.                                     local_msg.IDCMPWindow );
  356.                break;
  357.          }
  358.  
  359.          Respond( (struct Interactor *)&GraphicTool.pw,    &local_msg );
  360.          Respond( (struct Interactor *)&IactorTool.pw,     &local_msg );
  361.          Respond( (struct Interactor *)&gridsnapwindow.pw, &local_msg );
  362.          Respond( (struct Interactor *)&builderwindow.pw,  &local_msg );
  363.  
  364.          while( ( node = (struct FuncNode *)
  365.                         RemHead( (struct List *)&DeferredResponses ) )
  366.                 != NULL )
  367.          {
  368.             (*node->func)( node->UserData );
  369.             FreeFuncNode( node );
  370.          }
  371.  
  372.       }
  373.    }
  374.  
  375.    Builder_CleanUp();
  376. }
  377.  
  378. void EditEnvironment( struct MsgPort *shared_port )
  379. {
  380.    TitleBox          titlebox;
  381.    OutlineBox        outlinebox;
  382.    BoolGadget        boolgadget;
  383.    CheckBox          checkbox;
  384.    StringGadget      stringgadget;
  385.    IntegerGadget     intgadget;
  386.    HSlider           hslider;
  387.    HScroller         hscroller;
  388.    VSlider           vslider;
  389.    VScroller         vscroller;
  390.    ScrollingList     scrollinglist;
  391.    ListEditor        listeditor;
  392.    CycleGadget       cyclegadget;
  393.    pcg_3DPens        pens;
  394.  
  395. /*   pens = StandardPens(); */
  396.    pens = StandardScreenPens( NULL );
  397.  
  398.    menustrip = mnu_BuildMenus();
  399.  
  400.    /* DUMPWAIT("gridsnapinit\n"); */
  401.    GridSnapWindow_Init( &gridsnapwindow, screen, shared_port, pens );
  402.    AddWindowToChain( &gridsnapwindow.pw );
  403.  
  404.  
  405.    /***************** Tool Window initialization. ****************/
  406.    /* DUMPWAIT("toolwindowinit 1\n"); */
  407.    ToolWindow_Init( &GraphicTool, 200, 212, screen, shared_port, pens, "Graphics" );
  408.    AddWindowToChain( &GraphicTool.pw );
  409.  
  410.  
  411.    TitleBox_Init( &titlebox, 0, 0, 160, 20, pens, "label");
  412.    ToolWindow_AddArchetype( &GraphicTool, (struct GraphicObject *)&titlebox );
  413.  
  414.    OutlineBox_Init( &outlinebox, 0, 0, 90, 50, pens, " label ");
  415.    ToolWindow_AddArchetype( &GraphicTool, (struct GraphicObject *)&outlinebox );
  416.  
  417.  
  418.    /* DUMPWAIT("toolwindowinit 2\n");  */
  419.    ToolWindow_Init( &IactorTool, 400, 212, screen, shared_port, pens, "Gadgets" );
  420.    AddWindowToChain( &IactorTool.pw );
  421.  
  422.    /* DUMPWAIT("bool\n");  */
  423.    BoolGadget_Init( &boolgadget, 0, 0, 96, 14, pens, "label" );
  424.    ToolWindow_AddArchetype( &IactorTool, (struct GraphicObject *)&boolgadget );
  425.  
  426.    CheckBox_Init( &checkbox, 0, 0, pens, "label", TRUE );
  427.    ToolWindow_AddArchetype( &IactorTool, (struct GraphicObject *)&checkbox );
  428.  
  429.  
  430.    /* DUMPWAIT("cycle\n"); */
  431.    CycleGadget_Init( &cyclegadget, 0, 0, 96, pens, "label:", cyclegadget_choices );
  432.    ToolWindow_AddArchetype( &IactorTool, (struct GraphicObject *)&cyclegadget );
  433.  
  434.    /* DUMPWAIT("string\n"); */
  435.    StringGadget_Init( &stringgadget, 0, 0, 112, 256, pens, "label:" );
  436.    ToolWindow_AddArchetype( &IactorTool, (struct GraphicObject *)&stringgadget );
  437.  
  438.    /* DUMPWAIT("integer\n"); */
  439.    IntegerGadget_Init( &intgadget, 0,0, 48, 10, pens, "label:" );
  440.    ToolWindow_AddArchetype( &IactorTool, (struct GraphicObject *)&intgadget );
  441.  
  442.    /* DUMPWAIT("hslider\n"); */
  443.    HSlider_Init( &hslider, 0, 0, 100, 16, pens, "label:" );
  444.    ToolWindow_AddArchetype( &IactorTool, (struct GraphicObject *)&hslider );
  445.  
  446.    /* DUMPWAIT("hscroller\n");  */
  447.    HScroller_Init( &hscroller, 0, 0, 100, pens, "label:" );
  448.    ToolWindow_AddArchetype( &IactorTool, (struct GraphicObject *)&hscroller );
  449.  
  450.    /* DUMPWAIT("vslider\n");  */
  451.    VSlider_Init( &vslider, 0, 0, 16, 100, pens, "label" );
  452.    ToolWindow_AddArchetype( &IactorTool, (struct GraphicObject *)&vslider );
  453.  
  454.    /* DUMPWAIT("vscroller\n"); */
  455.    VScroller_Init( &vscroller, 0, 0, 100, pens, "label" );
  456.    ToolWindow_AddArchetype( &IactorTool, (struct GraphicObject *)&vscroller );
  457.  
  458.    /* DUMPWAIT("scrollinglist\n"); */
  459.    ScrollingList_Init( &scrollinglist, 0, 0, 150, 100, pens, FALSE );
  460.    ToolWindow_AddArchetype( &IactorTool, (struct GraphicObject *)&scrollinglist );
  461.  
  462.    /* DUMPWAIT("listeditor\n"); */
  463.    ListEditor_Init( &listeditor, 0,0, 150, 100, pens, "label:" );
  464.    ToolWindow_AddArchetype( &IactorTool, (struct GraphicObject *)&listeditor );
  465.  
  466.    /* DUMPWAIT("after openwindow\n");  */
  467.  
  468.    main_PositionTools( screen, &IactorTool, &GraphicTool );
  469.    pcgOpenWindow( &IactorTool.pw );
  470.    pcgOpenWindow( &GraphicTool.pw );
  471.  
  472.    AddMenuStrip( &GraphicTool.pw,      menustrip );
  473.    AddMenuStrip( &IactorTool.pw,       menustrip );
  474.    AddMenuStrip( &gridsnapwindow.pw,   menustrip );
  475.  
  476.  
  477.    Builder_EventLoop();
  478.  
  479.    pcgCloseWindow( &IactorTool.pw );
  480.    pcgCloseWindow( &GraphicTool.pw );
  481.    pcgCloseWindow( &gridsnapwindow.pw );
  482.  
  483.    CleanUp( (struct PObject *)&IactorTool.pw );
  484.    CleanUp( (struct PObject *)&GraphicTool.pw );
  485.    CleanUp( (struct PObject *)&gridsnapwindow );
  486.  
  487.    CleanUp( (struct PObject *)&titlebox );
  488.    CleanUp( (struct PObject *)&outlinebox );
  489.    CleanUp( (struct PObject *)&boolgadget );
  490.    CleanUp( (struct PObject *)&checkbox );
  491.    CleanUp( (struct PObject *)&cyclegadget );
  492.    CleanUp( (struct PObject *)&stringgadget );
  493.    CleanUp( (struct PObject *)&intgadget );
  494.    CleanUp( (struct PObject *)&hslider );
  495.    CleanUp( (struct PObject *)&hscroller );
  496.    CleanUp( (struct PObject *)&vslider );
  497.    CleanUp( (struct PObject *)&vscroller );
  498.    CleanUp( (struct PObject *)&scrollinglist );
  499.    CleanUp( (struct PObject *)&listeditor );
  500. }
  501.  
  502. #define DEFER(f) QueueFunc( &DeferredResponses, (ptr2func) f, NULL )
  503.  
  504. void main_ParseMenuEvent( BuilderWindow       *bw,
  505.                           USHORT               MenuNumber,
  506.                           Window              *window )
  507. {
  508.    pcg_MenuItem *item;
  509.  
  510.    if( MenuNumber == MENUNULL ) return;
  511.  
  512.    item = (pcg_MenuItem *)
  513.       ItemAddress( window->MenuStrip, MenuNumber );
  514.  
  515.    switch( item->ItemID )
  516.    {
  517.       case PROJECT_NEW_ID:
  518.          DEFER ( Project_New );
  519.          break;
  520.  
  521.       case PROJECT_OPEN_ID:
  522.          DEFER ( Project_Open );
  523.          break;
  524.  
  525.       case PROJECT_SAVE_ID:
  526.          DEFER ( Project_Save );
  527.          break;
  528.  
  529.       case PROJECT_SAVE_AS_ID:
  530.          DEFER ( Project_Save_As );
  531.          break;
  532.  
  533.       case PROJECT_QUIT_ID:
  534.          DEFER ( Project_Quit );
  535.          break;
  536.  
  537.       case PROJECT_CODE_ID:
  538.          DEFER ( Project_WriteCode );
  539.          break;
  540.  
  541.       case PROJECT_ABOUT_ID:
  542.          DEFER ( Project_About );
  543.          break;
  544.    }
  545.  
  546.    main_ParseMenuEvent( bw, item->NextSelect, window );
  547. }
  548.  
  549.  
  550. void main_PositionTools( Screen     *screen,
  551.                          ToolWindow *tw1,
  552.                          ToolWindow *tw2 )
  553. {
  554.    Point size_tw1, loc_tw1, size_tw2;
  555.  
  556.    size_tw1 = Size( (struct GraphicObject *)&tw1->pw );
  557.    size_tw2 = Size( (struct GraphicObject *)&tw2->pw );
  558.  
  559.    SetLocation( (struct GraphicObject *)&tw1->pw, screen->Width - size_tw1.x -1, screen->Height - size_tw1.y -1 );
  560.    loc_tw1 = Location( (struct GraphicObject *)&tw1->pw );
  561.  
  562.    SetLocation( (struct GraphicObject *)&tw2->pw, loc_tw1.x - size_tw2.x, screen->Height - size_tw2.y -1 );
  563. }
  564.  
  565.